home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 October / EnigmA AMIGA RUN 01 (1995)(G.R. Edizioni)(IT)[!][issue 1995-10][Aminet 7].iso / Aminet / dev / gui / BGUI11c.lha / docs / windowclass.doc < prev   
Text File  |  1995-04-23  |  28KB  |  776 lines
  1.  
  2.                File: windowclass.doc
  3.         Description: Windowclass documentation.
  4.           Copyright: (C) Copyright 1994-1995 Jaba Development.
  5.                      (C) Copyright 1994-1995 Jan van den Baard.
  6.                      All Rights Reserved.
  7.  
  8. ------------------------------------------------------------------------------
  9.  
  10. TABLE OF CONTENTS
  11.  
  12. windowclass/--background--
  13. windowclass/Methods
  14. windowclass/Attributes
  15.  
  16. windowclass/--background--                          windowclass/--background--
  17.  
  18.     NAME
  19.         Class:          windowclass
  20.         Superclass:     ROOTCLASS
  21.         Include File:   <libraries/bgui.h>
  22.  
  23.     FUNCTION
  24.         To  provide  an  easy  to use BGUI interface to intuition windows. The
  25.         window  class  provides just about anything you need to create windows
  26.         with a fully font sensitive and size adjustable GUI.
  27.  
  28. windowclass/Methods                                        windowclass/Methods
  29.  
  30.     NEW METHODS
  31.         WM_OPEN -- This method must be used to open the window.  When a window
  32.                 object is created it does not open right away.
  33.  
  34.                 Returns a pointer to the opened window uppon success  and NULL
  35.                 uppon failure.
  36.  
  37.         WM_CLOSE -- This method must be used to close the window again.  It is
  38.                 safe to call this method even when the window is not open.
  39.  
  40.                 Returns TRUE uppon success and FALSE uppon failure.
  41.  
  42.         WM_SLEEP -- With this method you can put your window to sleep  when it
  43.                 is  open.   This  is  done  by  setting  up a  small invisible
  44.                 requester and a busy pointer.
  45.  
  46.                 Returns TRUE uppon success and FALSE uppon failure.
  47.  
  48.         WM_WAKEUP -- This methos must be  used to  wake  up the  window again.
  49.                 Please note that you must wake up the window as many  times as
  50.                 you have put it to sleep before you can actually use it again.
  51.                 Both the WM_SLEEP and WM_WAKEUP methods can be nested.
  52.  
  53.                 Returns TRUE uppon success and FALSE uppon failure.
  54.  
  55.         WM_HANDLEIDCMP -- This method must be  used  to call  the  windowclass
  56.                 event handler. The event handler will  act  uppon the messages
  57.                 present at the window it's message  port  and  return  you one
  58.                 of the following return codes:
  59.  
  60.                 WMHI_CLOSEWINDOW -- The window it's close gadget was selected.
  61.                 WMHI_NOMORE -- No more messages waiting.
  62.                 WMHI_INACTIVE -- The window was de-activated.
  63.                 WMHI_ACTIVE -- The window was activated.
  64.                 WMHI_IGNORE -- Ignore this result.
  65.  
  66.                 Any return code which differs from the ones  above is  the  ID
  67.                 of a selected object (gadget or menu).
  68.  
  69.                 Please look at the demo programs for more information.
  70.  
  71.         WM_GADGETKEY -- With this method you  can  assign a  key to  trigger a
  72.                 gadget object in the window.  This method  uses the  following
  73.                 custom message structure:
  74.  
  75.                 struct wmGadgetKey {
  76.                         ULONG             MethodID;  /* WM_GADGETKEY */
  77.                         struct Requester *wmgk_Requester;
  78.                         Object           *wmgk_Object;
  79.                         STRPTR            wmgk_Key;
  80.                 };
  81.  
  82.                 wmgk_Requester -- This version of the library does not support
  83.                         BGUI gadget objects in requesters  so this  field must
  84.                         be set to NULL.
  85.  
  86.                 wmgk_Object -- This must be  a  pointer to  the  object  which
  87.                         must be controlled by the key.
  88.  
  89.                 wmgk_Key -- This must point to a  string  in   which  a single
  90.                         character is located. The character is  the  key which
  91.                         controls the object when it is pressed.
  92.  
  93.                 Returns TRUE uppon success and FALSE uppon failure.
  94.  
  95.         WM_KEYACTIVE, WM_KEYINPUT, WM_KEY_INACTIVE -- These three  methods are
  96.                 sent to the gadget object during a key-session.  Please  refer
  97.                 to the "methods.doc" file for more information.
  98.  
  99.         WM_DISABLEMENU, WM_CHECKITEM -- These  two  methods  must  be  used to
  100.                 disable or enable a menu or a menu item or to set or clear the
  101.                 check mark of a CHECKIT item.   These  methods  both  use  the
  102.                 following custom message structure:
  103.  
  104.                 struct wmMenuAction {
  105.                         ULONG             MethodID; /* Any of the above. */
  106.                         ULONG             wmma_MenuID;
  107.                         ULONG             wmma_Set;
  108.                 };
  109.  
  110.                 wmma_MenuID -- This must be the ID of the  menu/item  on which
  111.                         the operation is done. The ID is  the value  which you
  112.                         set in the nm_UserData field of the NewMenu structure.
  113.  
  114.                 wmma_Set -- This is a boolean which  disables/checks  the menu
  115.                         when set to  TRUE  or  enables/unchecks the  menu when
  116.                         set to FALSE.
  117.  
  118.                 Returns TRUE uppon success and FALSE uppon failure.
  119.  
  120.         WM_MENUDISABLED, WM_ITEMCHECKED -- These two methods  must  be used to
  121.                 query about the disabled/checked state of a menu. Both methods
  122.                 use the following custom message structure:
  123.  
  124.                 struct wmMenuQuery {
  125.                         ULONG             MethodID; /* Any of the above. */
  126.                         ULONG             wmmq_MenuID;
  127.                 };
  128.  
  129.                 wmmq_MenuID -- This must be the ID of the  menu/item  on which
  130.                         the operation is done. The ID is  the value  which you
  131.                         set in the nm_UserData field of the NewMenu structure.
  132.  
  133.                 Returns TRUE if the menu is disabled/checked and FALSE if not.
  134.                 A return code of ~0 means that the menu is unknown or no menus
  135.                 are available.
  136.  
  137.         WM_TABCYCLE_ORDER -- With this method you can  determine the  order of
  138.                 tab-cycling.  This method uses  the  following  custom message
  139.                 structure:
  140.  
  141.                 struct wmTabCycleOrder {
  142.                         ULONG             MethodID; /* WM_TABCYCLE_ORDER */
  143.                         Object           *wtco_Object1;
  144.                         /* Object        *wtco_Object2; */
  145.                         /* ... */
  146.                         /* NULL */
  147.                 };
  148.  
  149.                 wtco_Object1 -- The first of a the objects which  will be  set
  150.                         in the tab-cycle chain.   Please  note  that you  must
  151.                         terminate the method with a NULL pointer.
  152.  
  153.                 Returns TRUE uppon success and FALSE uppon failure.
  154.  
  155.         WM_GETAPPMSG -- This method must be used  to get the AppWindow message
  156.                 when one is available.  Please note that _you_ are  resposible
  157.                 for replying the message.
  158.  
  159.                 Returns a pointer to the AppMessage or NULL when  there was no
  160.                 message.
  161.  
  162.         WM_ADDUPDATE -- This method must be used  to  perform  simple map-list
  163.                 notification with  externalclass  objects.  The  externalclass
  164.                 objects are not able to perform  notification  like  the other
  165.                 gadget classes. This method uses the  following custom message
  166.                 structure:
  167.  
  168.                 struct wmAddUpdate {
  169.                         ULONG             MethodID; /* WM_ADDUPDATE */
  170.                         ULONG             wmau_SourceID;
  171.                         Object           *wmau_Target;
  172.                         struct TagItem   *wmau_MapList;
  173.                 };
  174.  
  175.                 wmau_SourceID -- This must be the ID of the object that send's
  176.                         the notification message.
  177.  
  178.                 wmau_Target -- This must be a  pointer  to  the  object  which
  179.                         must be updated by the notiication.
  180.  
  181.                 wmau_MapList -- This can pointe to  an  array  of  tags  which
  182.                         contain the attributes to map.  This may also  be NULL
  183.                         in which case no mapping is done.
  184.  
  185.                 Return TRUE uppon success and FALSE uppon failure.
  186.  
  187.         WM_REPORT_ID ** V38 ** -- This method  will  allow  an  IDCMP-hook  or
  188.                 Verify-hook to report ID's  to  the  application program.   It
  189.                 will  stack  the  ID(s)  to  report  and  pass  them  to   the
  190.                 application the next time the WM_HANDLEIDCMP method is called.
  191.                 This  method  uses the following custom message structure:
  192.  
  193.                 struct wmReportID {
  194.                         ULONG           MethodID;       /* WM_REPORT_ID     */
  195.                         ULONG           wmri_ID;
  196.                         ULONG           wmri_Flags;
  197.                 };
  198.  
  199.                 wmri_ID -- This is the ID that is put on the stack.  Next time
  200.                         the application  call's  WM_HANDLEIDCMP on  the object
  201.                         the ID's on the stack are returned.
  202.  
  203.                 wmri_Flags -- This may contain any of the following flags:
  204.  
  205.                         WMRIF_DOUBLE_CLICK -- When this flag is set  the ID to
  206.                                 report   is  put  on  the  stack  twice  which
  207.                                 effectivly simulates a double-click.
  208.  
  209.                 Returns TRUE uppon success and FALSE uppon failure.
  210.  
  211.     CHANGED METHODS
  212.         OM_DISPOSE -- When  this  method is called all objects attached to the
  213.                 window with the WINDOW_MasterGroup attribute are also disposed
  214.                 of.
  215.  
  216. windowclass/Attributes                                  windowclass/Attributes
  217.  
  218.     NAME
  219.         WINDOW_Position -- ( ULONG )
  220.  
  221.     FUNCTION
  222.         To determine the position at which the window is opened. These are the
  223.         possibilities:
  224.  
  225.         POS_CENTERSCREEN -- The window is centered in the visible part  of the
  226.                 screen it is opened on.
  227.         POS_CENTERMOUSE -- The window is centered under  the mouse.  Depending
  228.                 on the location of the mouse this might differ a little.
  229.         POS_TOPLEFT -- The window is opened  at  the  top-left  corner  in the
  230.                 visible part of the screen it is opened on.
  231.  
  232.         Default is POS_CENTERSCREEN. Applicability is (I).
  233.  
  234.     SEE ALSO
  235.         WINDOW_PosRelBox
  236.  
  237.     NAME
  238.         WINDOW_ScaleWidth, WINDOW_ScaleHeight -- ( ULONG )
  239.  
  240.     FUNCTION
  241.         To open a window larger than it's minimum size. The data you pass with
  242.         these tags must be the percentage (0%..100%) of the  visible  size  of
  243.         the screen minus the minimum size of the window.  For example you have
  244.         a  window which is 100 pixels wide at it's minimum size  on  a  screen
  245.         which   is  1000   pixels   wide   (visible)   and   you  pass  25  as
  246.         WINDOW_ScaleWidth  the window is opened 325 pixels wide.
  247.  
  248.         (( 1000 - 100 ) / 100 ) * 25 = 225
  249.  
  250.         225 + 100 = 325
  251.  
  252.         Defaults are 0. Applicability is (I).
  253.  
  254.     NAME
  255.         WINDOW_LockWidth, WINDOW_LockHeight -- ( BOOL )
  256.  
  257.     FUNCTION
  258.         To disable sizing the width or height of a window.
  259.  
  260.         Defaults are FALSE. Applicability is (I).
  261.  
  262.     NAME
  263.         WINDOW_PosRelBox -- ( struct IBox * )
  264.  
  265.     FUNCTION
  266.         To open the window centered in the described box.  The  data  you pass
  267.         here must be a pointer to a struct IBox in which the location and size
  268.         of the box is described. This will allow you to easely center a window
  269.         uppon another window like this:
  270.  
  271.         struct Window           *parent;
  272.         struct IBox              position;
  273.         Object                  *window_object;
  274.  
  275.         /*
  276.         **      Copy the parent location/size.
  277.         **/
  278.         position = *(( struct IBox * )&parent->LeftEdge );
  279.  
  280.         window_object = WindowObject,
  281.                 WINDOW_PosRelBox,               &position,
  282.                 ....
  283.         EndObject;
  284.  
  285.     SEE ALSO
  286.         WINDOW_Position
  287.  
  288.     NAME
  289.         WINDOW_DragBar,         WINDOW_SizeGadget,         WINDOW_CloseGadget,
  290.         WINDOW_DepthGadget -- ( BOOL )
  291.  
  292.     FUNCTION
  293.         To switch on or off the corresponding system gadgets.
  294.  
  295.         Default for all are TRUE. Applicability is (I).
  296.  
  297.     NAME
  298.         WINDOW_SizeBottom, WINDOW_SizeBright -- ( BOOL )
  299.  
  300.     FUNCTION
  301.         To determine the place of the sizing gadget.
  302.  
  303.         Default is TRUE for bottom and FALSE for right. Applicability is (I).
  304.  
  305.     NAME
  306.         WINDOW_Activate -- ( BOOL )
  307.  
  308.     FUNCTION
  309.         To activate the window right after it is opened.
  310.  
  311.         Default is TRUE. Applicability is (I).
  312.  
  313.     NAME
  314.         WINDOW_RMBTrap -- ( BOOL )
  315.  
  316.     FUNCTION
  317.         To set/clear the WFLG_RMBTRAP  flag.  When set this disables the right
  318.         from  activating  the  menu-strip.   It will also make the right mouse
  319.         button visible in intuition events.
  320.  
  321.         Default is FALSE. Applicability is (I).
  322.  
  323.     NAME
  324.         WINDOW_SmartRefresh -- ( BOOL )
  325.  
  326.     FUNCTION
  327.         To set/clear the WFLG_SMART_REFRESH flag.
  328.  
  329.         Default is FALSE. Applicability is (I).
  330.  
  331.     NAME
  332.         WINDOW_ReportMouse -- ( BOOL )
  333.  
  334.     FUNCTION
  335.         To set/clear the WFLG_REPORTMOUSE flags.
  336.  
  337.         Default is FALSE. Applicability is (I).
  338.  
  339.     NAME
  340.         WINDOW_IDCMP -- ( ULONG )
  341.  
  342.     FUNCTION
  343.         To set extra IDCMP flags which are not automatically set by the window
  344.         class  itself.  This  might  be  necessary  for  the  WINDOW_IDCMPHook
  345.         described below.   The following  flags are  automatically set  by the
  346.         window class:
  347.  
  348.         IDCMP_RAWKEY                    - Key control of gadgets.
  349.         IDCMP_GADGETUP                  - The obvious.
  350.         IDCMP_CHANGEWINDOW              - To track window changes.
  351.         IDCMP_INACTIVEWINDOW            - To report window inactivation.
  352.         IDCMP_ACTIVEWINDOW              - To report window activation.
  353.         IDCMP_IDCMPUPDATE               - For WM_ADDUPDATE notification,
  354.                                           tab-cycling and continues slider and
  355.                                           scroller reporting.
  356.         IDCMP_CLOSEWINDOW               - To report clicking the close gadget.
  357.         IDCMP_MENUPICK                  - To report menu-selections.
  358.  
  359.         Please  note  that  IDCMP_VANILLAKEY  must  _not_  be set. The current
  360.         keyboard handling does not allow this.
  361.  
  362.         Default is 0. Applicability is (I).
  363.  
  364.     SEE ALSO
  365.         WINDOW_IDCMPHook
  366.  
  367.     NAME
  368.         WINDOW_SharedPort -- ( struct MsgPort * )
  369.  
  370.     FUNCTION
  371.         To use a shared message port for the window.  If you pass a pointer to
  372.         a valid message port here the window will use this  port for receiving
  373.         events.
  374.  
  375.         Default is NULL. Applicability is (I).
  376.  
  377.     NAME
  378.         WINDOW_Title, WINDOW_ScreenTitle -- ( STRPTR )
  379.  
  380.     FUNCTION
  381.         To set the window title and the title of  the screen  while the window
  382.         is active.
  383.  
  384.         Defaults are NULL. Applicability is (ISU).
  385.  
  386.     NAME
  387.         WINDOW_MenuStrip -- ( struct NewMenu * ) ( struct Menu * )
  388.  
  389.     FUNCTION
  390.         This attribute has two data types to be considered.  Uppon creation of
  391.         the  window  object  the  data  expected  is  a pointer to an array of
  392.         NewMenu  structures  as  defined  in  <libraries/gadtools.h>. When you
  393.         obtain  this  attribute  with  OM_GET  you  will  get a pointer to the
  394.         created menus.
  395.  
  396.         To  make  the  menus  visible  to  your  program  you  must give every
  397.         selectable  menu an ID. The ID must be placed in the nm_UserData field
  398.         of the corresponding NewMenu structure.
  399.  
  400.         Example:
  401.  
  402.         #define ID_ABOUT        1
  403.         #define ID_QUIT         2
  404.  
  405.         struct NewMenu Menus {
  406.                 { NM_TITLE,  "Project",   NULL, 0, 0, NULL },
  407.                 { NM_ITEM,   "About...",  "?",  0, 0, (APTR)ID_ABOUT },
  408.                 { NM_ITEM,   NM_BARLABEL, NULL, 0, 0, NULL },
  409.                 { NM_ITEM,   "Quit",      "Q",  0, 0, (APTR)ID_QUIT },
  410.                 { NM_END,    NULL,        NULL, 0, 0, NULL }
  411.         }
  412.  
  413.         The  WM_HANDLEIDCMP  method  will  return ID_ABOUT when the "About..."
  414.         item is selected and ID_QUIT when the "Quit" item is selected.
  415.  
  416.         Default is NULL. Applicability is (IG).
  417.  
  418.         NOTE: Since V38.6 of the library the windowclass will  make  a private
  419.               copy of the passed NewMenu array.  The  strings of the items are
  420.               NOT copied and must remain valid.
  421.  
  422.     NAME
  423.         WINDOW_MasterGroup -- ( Object * )
  424.  
  425.     FUNCTION
  426.         To  set  the master group containing all objects for the window.  This
  427.         attribute   data   _must_  point  to a valid groupclass object or else
  428.         the  window  object  creation    will    fail.   It's   currently  not
  429.         possible   to   create   a  windowclass  object without a group object
  430.         attached  to it. The data expected here is a pointer to the groupclass
  431.         object  containing  all other gadget objects.
  432.  
  433.         Example:
  434.  
  435.         Object                  *WO_Window;
  436.  
  437.         WO_Window = WindowObject,
  438.                 WINDOW_Title,           "Whatever",
  439.                 ...
  440.                 WINDOW_MasterGroup,
  441.                         HGroupObject, HOffset( 4 ), VOffset( 4 ),
  442.                                 StartMember,
  443.                                         Button( "Quit", 0 ),
  444.                                 EndMember,
  445.                         EndObject,
  446.         EndObject;
  447.  
  448.         Default is NULL. Applicability is (I).
  449.  
  450.     NAME
  451.         WINDOW_Screen -- ( struct Screen * )
  452.  
  453.     FUNCTION
  454.         To set the custom screen on which the window should open.  If you want
  455.         your  window  to  open on a custom screen you can pass a pointer to it
  456.         here.  Please  note  that you  can use OM_SET to change this attribute
  457.         only when the window is not open.
  458.  
  459.         Default is NULL (default public screen). Applicability is (IS).
  460.  
  461.     SEE ALSO
  462.         WINDOW_PubScreenName
  463.  
  464.     NAME
  465.         WINDOW_PubScreenName -- ( STRPTR )
  466.  
  467.     FUNCTION
  468.         To set the name of the public screen on which the window should  open.
  469.         Please note that you can use  OM_SET  to change  this  attribute  only
  470.         when the window is not open.
  471.  
  472.         Default is NULL (default public screen). Applicability is (IS).
  473.  
  474.     SEE ALSO
  475.         WINDOW_Screen
  476.  
  477.     NAME
  478.         WINDOW_UserPort -- ( struct MsgPort * )
  479.  
  480.     FUNCTION
  481.         To obtain a pointer to the message port of the window.
  482.  
  483.         Applicability is (G).
  484.  
  485.     NAME
  486.         WINDOW_SigMask -- ( ULONG )
  487.  
  488.     FUNCTION
  489.         To  obtain  the  window signal mask.
  490.  
  491.         Example:
  492.  
  493.         Object         *WO_Win;
  494.         ULONG           mask;
  495.  
  496.         GetAttr( WINDOW_SigMask, WO_Win, &mask );
  497.  
  498.         do {
  499.                 Wait( mask );
  500.                 ...
  501.         } while ( ... );
  502.  
  503.         Applicability is (G).
  504.  
  505.     SEE ALSO
  506.         WINDOW_AppMask
  507.  
  508.     NAME
  509.         WINDOW_IDCMPHook, WINDOW_VerifyHook -- ( struct Hook * )
  510.  
  511.     FUNCTION
  512.         To  tie  yourself  into  the IDCMP handling of the window.  With these
  513.         attributes  you  can  set a hook which is called uppon  events set  by
  514.         the  WINDOW_IDCMPHookBits and/or WINDOW_VerifyHookBits attributes. The
  515.         hooks are called as follows:
  516.  
  517.         void hookRoutine( hook, object, imsg )
  518.                           A0    A2      A1
  519.  
  520.         struct Hook             *hook;
  521.         Object                  *object;
  522.         struct IntuiMessage     *imsg;
  523.  
  524.         The  pointer  to  the  IntuiMessage  structure  is read-only. Also the
  525.         message  is  passed to you before it is reply'd so you should not take
  526.         to long before returning.
  527.  
  528.         The  IDCMPHook  is  called  after  the window object has done it's own
  529.         processing on the message. The VerifyHook is called directly while the
  530.         window object does not need to process any verification messages.
  531.  
  532.         Default is NULL. Applicability is (I).
  533.  
  534.     SEE ALSO
  535.         WINDOW_IDCMP, WINDOW_IDCMPHookBits, WINDOW_VerifyHookBits
  536.  
  537.     NAME
  538.         WINDOW_IDCMPHookBits, WINDOW_VerifyHookBits -- ( ULONG )
  539.  
  540.     FUNCTION
  541.         To  set  the  bits  that  will cause the IDCMPHook or VerifyHook to be
  542.         called.  The bits you pass here are the standard system IDCMP_xxx flag
  543.         bits  found in <intuition/intuition.h>. Please note that some of these
  544.         bits  require  you  to set them first using the WINDOW_IDCMP attribute
  545.         described above.
  546.  
  547.         Example:
  548.  
  549.         struct Hook             *idcmp_hook;
  550.         Object                  *wd_obj;
  551.  
  552.         wd_obj = WindowObject,
  553.                 WINDOW_IDCMP,           IDCMP_INTUITICKS,
  554.                 WINDOW_IDCMPHook,       idcmp_hook,
  555.                 WINDOW_IDCMPHookBits,   IDCMP_INTUITICKS,
  556.                 ...
  557.         EndObject;
  558.  
  559.         This   will   cause   the   WINDOW_IDCMPHook  to  be  called  at  each
  560.         IDCMP_INTUITICKS event.
  561.  
  562.         Please note that the window class does not filter  out  any non-verify
  563.         bits  from  the WINDOW_VerifyHookBits you pass. This means that if you
  564.         set  IDCMP_GADGETUP  in  the  verification bits you will block out the
  565.         window  object  event  handler  from  receiving  gadget  messages. The
  566.         verification bits set should be restricted to the following bits:
  567.  
  568.         IDCMP_REQVERIFY
  569.         IDCMP_MENUVERIFY
  570.  
  571.         Defaults are 0. Applicability is (I).
  572.  
  573.     SEE ALSO
  574.         WINDOW_IDCMP, WINDOW_IDCMPHook, WINDOW_VerifyHook
  575.  
  576.     NAME
  577.         WINDOW_Font -- ( struct TextAttr * )
  578.  
  579.     FUNCTION
  580.         To  set the font to be used by the gadget objects. By default the font
  581.         of  the  screen the window is opened on is used. With this tag you can
  582.         select your own font.  Note that the font is opened with OpenFont() so
  583.         please make sure it is present in memory.
  584.  
  585.         Default is NULL. Applicability is (I).
  586.  
  587.     SEE ALSO
  588.         WINDOW_FallBackFont
  589.  
  590.     NAME
  591.         WINDOW_FallBackFont -- ( struct TextAttr * )
  592.  
  593.     FUNCTION
  594.         To  set the font to try whenever a window fails to open because it has
  595.         grown  to big for the screen. By default the fallback font is topaz 8.
  596.         If  you  pass a TextAttr here the window object will first try to fall
  597.         back  to  the supplied font and, if that also fails, it will try topaz
  598.         8. When topaz 8 fails the window will not open.  Note that the font is
  599.         opened with OpenFont() so please make sure it is present in memory.
  600.  
  601.         Default is NULL. Applicability is (I).
  602.  
  603.     SEE ALSO
  604.         WINDOW_Font
  605.  
  606.     NAME
  607.         WINDOW_HelpFile -- ( STRPTR )
  608.  
  609.     FUNCTION
  610.         Set the name of the file to be displayed when a  help-request  for the
  611.         object arives. Please note that the full path-name must be given.
  612.  
  613.         Default is NULL. Applicability is (IS).
  614.  
  615.     SEE ALSO
  616.         WINDOW_HelpNode, WINDOW_HelpLine
  617.  
  618.     NAME
  619.         WINDOW_HelpNode -- ( STRPTR )
  620.  
  621.     FUNCTION
  622.         Set the name of the node which is diplayed in the help window.
  623.  
  624.         Default is NULL. Applicability is (IS).
  625.  
  626.     SEE ALSO
  627.         WINDOW_HelpFile, WINDOW_HelpLine
  628.  
  629.     NAME
  630.         WINDOW_HelpLine - ( ULONG )
  631.  
  632.     FUNCTION
  633.         Set the line number  from  which the  file is  displayed.  This may be
  634.         useful if the help-file is not an AmigaGuide file.
  635.  
  636.         Default is 0. Applicability is (IS).
  637.  
  638.     SEE ALSO
  639.         WINDOW_HelpFile, WINDOW_HelpNode
  640.  
  641.     NAME
  642.         WINDOW_AppWindow -- ( BOOL )
  643.  
  644.     FUNCTION
  645.         To make the window an AppWindow.
  646.  
  647.         Default is FALSE. Applicability is (I).
  648.  
  649.     SEE ALSO
  650.         WINDOW_AppMask
  651.  
  652.     NAME
  653.         WINDOW_AppMask -- ( ULONG )
  654.  
  655.     FUNCTION
  656.         To  obtain  the app-window signal mask.
  657.  
  658.         Example:
  659.  
  660.         Object         *WO_Win;
  661.         ULONG           mask;
  662.  
  663.         GetAttr( WINDOW_AppMask, WO_Win, &mask );
  664.  
  665.         do {
  666.                 Wait( mask );
  667.                 ...
  668.         } while ( ... );
  669.  
  670.         Applicability is (G).
  671.  
  672.     SEE ALSO
  673.         WINDOW_SigMask
  674.  
  675.     NAME
  676.         WINDOW_UniqueID -- ( ULONG )
  677.  
  678.     FUNCTION
  679.         To provide the window with an ID. The ID must be a 32bit integer which
  680.         is  used  to  store  information on the window it's position and size.
  681.         This  allows  you to close and dispose of the window object, re-create
  682.         it  with the same ID, and the position and size of the window the last
  683.         time it was open is still the same.
  684.  
  685.         This tag  tracks  the  complete window bounds but if you re-create and
  686.         open your window with the WINDOW_PosRelBox tag specified only the size
  687.         of the  window is re-stored. The size will remain the same as the last
  688.         time the  window  was  open  but  the position will be adjusted to the
  689.         bounds specified with the WINDOW_PosRelBox tag.
  690.  
  691.         The ID must be non-NULL.
  692.  
  693.         Default is 0 (no storage is done). Applicability is (I).
  694.  
  695.     SEE ALSO
  696.         WINDOW_PosRelBox
  697.  
  698.     NAME
  699.         WINDOW_Window -- ( struct Window * )
  700.  
  701.     FUNCTION
  702.         To get a pointer to the window structure.  The pointer you get will be
  703.         NULL if the window is not opened.
  704.  
  705.         Applicability is (G).
  706.  
  707.     NAME
  708.         WINDOW_Bounds -- ( struct IBox * )
  709.  
  710.     FUNCTION
  711.         To  enable  you  to pick the position and the size of the window. This
  712.         attribute expects a pointer to a struct IBox in which the position and
  713.         size are stored. The windowclass will check the values and adjust them
  714.         if necessary. I.E. You cannot specify a size smaller than  the minimum
  715.         possible size.  Query this attribute with  OM_GET to find  out exactly
  716.         where the window is located and what it's size is.
  717.  
  718.         Querying this attribute with OM_GET is only  possible when  the window
  719.         is open. To get this attribute with OM_GET you specify  a pointer to a
  720.         struct IBox in the method.   The  class  will  write the bounds in the
  721.         struct IBox.
  722.  
  723.         Please  note  that  this   attribute   overides  the  WINDOW_Position,
  724.         WINDOW_ScaleWidth, WINDOW_ScaleHeight and WINDOW_PosRelBox attributes.
  725.  
  726.         Default is NULL. Applicability is (ISG).
  727.  
  728.     SEE ALSO
  729.         WINDOW_Position, WINDOW_ScaleWidth, WINDOW_ScaleHeight,
  730.         WINDOW_PosRelBox
  731.  
  732.     NAME
  733.         WINDOW_HelpText -- ( STRPTR)
  734.  
  735.     FUNCTION
  736.         To setup  a  text  which  will be displayed if the help-key is pressed
  737.         while the  mouse  pointer  is located above the window. This attribute
  738.         should be  used  to  attach small on-line help to the window. The text
  739.         you specify will be shown in a small BGUI_RequestA() type of requester
  740.         so you  must  make  sure  that  everything  fit's  nicely on a 600x200
  741.         screen.
  742.  
  743.         The specified text may contain any of the infoclass command sequences.
  744.  
  745.         This   attribute  overides  the  WINDOW_HelpFile,  WINDOW_HelpNode and
  746.         WINDOW_HelpLine attributes.
  747.  
  748.         Default is NULL. Applicability (IS).
  749.  
  750.     SEE ALSO
  751.         WINDOW_HelpFile, WINDOW_HelpNode, WINDOW_HelpLine,
  752.         infoclass/INFO_TextFormat, bgui.library/BGUI_RequestA()
  753.  
  754.     NAME
  755.         WINDOW_NoBufferRP -- ( BOOL )
  756.  
  757.     FUNCTION
  758.         When this attribute is  set to  TRUE the  windowclass  will  tell  the
  759.         layout engine not to  setup a  buffer  RastPort  which  means that all
  760.         rendering occures  on-screen.   This may be handy when you use objects
  761.         which  take  some  time  to  render  like the colorwheel.gadget on 256
  762.         colour screens.
  763.  
  764.         Default is FALSE. Applicability is (I).
  765.  
  766.     NAME
  767.         WINDOW_AutoAspect -- ( BOOL )
  768.  
  769.     FUNCTION
  770.         When this attribute is set the  windowclass  will  automatically  make
  771.         aspect ratio dependant decisions  about the  resulting GUI.  Currently
  772.         the only thing it does is selecting the frame  thickness.  Other stuff
  773.         like spacing and offsets might be added in the future.
  774.  
  775.         Default is FALSE. Applicability is (I).
  776.